{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.1. Principal Component Analysis\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width species\n",
       "0           5.1          3.5           1.4          0.2  setosa\n",
       "1           4.9          3.0           1.4          0.2  setosa\n",
       "2           4.7          3.2           1.3          0.2  setosa\n",
       "3           4.6          3.1           1.5          0.2  setosa\n",
       "4           5.0          3.6           1.4          0.2  setosa"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#importing the dataset\n",
    "iris_df = sns.load_dataset(\"iris\")\n",
    "\n",
    "#print dataset header\n",
    "iris_df.head()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating feature set\n",
    "X = iris_df.drop(['species'], axis=1)\n",
    "\n",
    "\n",
    "#creating label set\n",
    "y = iris_df[\"species\"]\n",
    "\n",
    "#converting labels to numbers\n",
    "from sklearn import preprocessing\n",
    "le = preprocessing.LabelEncoder()\n",
    "y = le.fit_transform(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dividing data into 80-20% traning and test sets\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,  test_size=0.20, random_state=0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#applying scaling on training and test data\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc = StandardScaler()\n",
    "X_train = sc.fit_transform(X_train)\n",
    "X_test = sc.transform (X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing PCA class\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "#creating object of the PCA class\n",
    "pca = PCA()\n",
    "\n",
    "#training PCA model on training data\n",
    "X_train = pca.fit_transform(X_train)\n",
    "\n",
    "#making predictions on test data\n",
    "X_test = pca.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.72229951 0.2397406  0.03335483 0.00460506]\n"
     ]
    }
   ],
   "source": [
    "#printing variance ratios\n",
    "variance_ratios = pca.explained_variance_ratio_\n",
    "print(variance_ratios)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#use one principle component\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X_train = pca.fit_transform(X_train)\n",
    "X_test = pca.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8666666666666667\n"
     ]
    }
   ],
   "source": [
    "#making predictions using logistic regression\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "#training the logistic regression model\n",
    "lg = LogisticRegression()\n",
    "lg.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = lg.predict(X_test)\n",
    "\n",
    "#evaluating results\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "print(accuracy_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x12ea1737610>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "#print actual datapoints\n",
    "\n",
    "plt.scatter(X_test[:,0], X_test[:,1], c= y_test, cmap='rainbow' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.2. Linear Discrimenant Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>variance</th>\n",
       "      <th>skewness</th>\n",
       "      <th>curtosis</th>\n",
       "      <th>entropy</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3.62160</td>\n",
       "      <td>8.6661</td>\n",
       "      <td>-2.8073</td>\n",
       "      <td>-0.44699</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.54590</td>\n",
       "      <td>8.1674</td>\n",
       "      <td>-2.4586</td>\n",
       "      <td>-1.46210</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.86600</td>\n",
       "      <td>-2.6383</td>\n",
       "      <td>1.9242</td>\n",
       "      <td>0.10645</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.45660</td>\n",
       "      <td>9.5228</td>\n",
       "      <td>-4.0112</td>\n",
       "      <td>-3.59440</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.32924</td>\n",
       "      <td>-4.4552</td>\n",
       "      <td>4.5718</td>\n",
       "      <td>-0.98880</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   variance  skewness  curtosis  entropy  class\n",
       "0   3.62160    8.6661   -2.8073 -0.44699      0\n",
       "1   4.54590    8.1674   -2.4586 -1.46210      0\n",
       "2   3.86600   -2.6383    1.9242  0.10645      0\n",
       "3   3.45660    9.5228   -4.0112 -3.59440      0\n",
       "4   0.32924   -4.4552    4.5718 -0.98880      0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#importing dataset\n",
    "banknote_df = pd.read_csv(r\"E:\\Hands on Python for Data Science and Machine Learning\\Datasets\\banknote.csv\")\n",
    "\n",
    "#displaying dataset header\n",
    "banknote_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dividing data into features and labels\n",
    "X = banknote_df.drop([\"class\"], axis = 1)\n",
    "y = banknote_df.filter([\"class\"], axis = 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dividing data into 80-20% traning and test sets\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,  test_size=0.20, random_state=0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "#applying scaling on training and test data\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc = StandardScaler()\n",
    "X_train = sc.fit_transform(X_train)\n",
    "X_test = sc.transform (X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "#importing LDA class\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "\n",
    "\n",
    "#creating object of the LDA class\n",
    "lda = LDA()\n",
    "\n",
    "#training PCA model on training data\n",
    "X_train = lda.fit_transform(X_train, y_train)\n",
    "\n",
    "#making predictions on test data\n",
    "X_test = lda.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.]\n"
     ]
    }
   ],
   "source": [
    "#printing variance ratios\n",
    "variance_ratios = lda.explained_variance_ratio_\n",
    "print(variance_ratios)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "#creating object of the LDA class\n",
    "lda = LDA(n_components = 1)\n",
    "\n",
    "#training PCA model on training data\n",
    "X_train = lda.fit_transform(X_train, y_train)\n",
    "\n",
    "#making predictions on test data\n",
    "X_test = lda.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9890909090909091\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:73: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "#making predictions using logistic regression\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "#training the logistic regression model\n",
    "lg = LogisticRegression()\n",
    "lg.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = lg.predict(X_test)\n",
    "\n",
    "#evaluating results\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "print(accuracy_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 10.1\n",
    "\n",
    "\n",
    "### Question 1\n",
    "\n",
    "Which of the following are the benefits of dimensionality reduction?\n",
    "\n",
    "A- Data Visualization \\\n",
    "B- Faster training time for statistical algorithms\\\n",
    "C- All of the above \\\n",
    "D- None of the above\n",
    "\n",
    "Answer: C\n",
    "    \n",
    "    \n",
    "### Question 2\n",
    "\n",
    "In PCA, dimensionality reduction depends upon the:\n",
    "\n",
    "A- Feature set only\\\n",
    "B- Label set only \\\n",
    "C- Both features and labels set \\\n",
    "D- None of the above\n",
    "\n",
    "Answer: A\n",
    "\n",
    "\n",
    "### Question 3\n",
    "\n",
    "LDA is a \\____ ? dimensionality reduction technique\n",
    "\n",
    "A- Unsupervised \\\n",
    "B- Semi-Supervised \\\n",
    "C- Supervised \\\n",
    "D- Reinforcement\n",
    "\n",
    "Answer: C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 10.2\n",
    "\n",
    "Apply principal component analysis for dimensionality reduction on the customer_churn.csv dataset from the dataset folder. Print the accuracy using 2 principal components. Also plot the results on test set using the two principal components"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.15034639 0.1028392  0.09996458 0.09293917 0.09151456 0.09055952\n",
      " 0.08971894 0.08848339 0.08157563 0.06903591 0.04302272]\n",
      "0.7975\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x12e9b9e6b20>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "churn_df = pd.read_csv(\"E:\\Hands on Python for Data Science and Machine Learning\\Datasets\\customer_churn.csv\")\n",
    "churn_df.head()\n",
    "\n",
    "churn_df = churn_df.drop(['RowNumber', 'CustomerId', 'Surname'], axis=1)\n",
    "\n",
    "X = churn_df.drop(['Exited'], axis=1)\n",
    "y = churn_df['Exited']\n",
    "\n",
    "numerical = X.drop(['Geography', 'Gender'], axis = 1)\n",
    "categorical = X.filter(['Geography', 'Gender'])\n",
    "cat_numerical = pd.get_dummies(categorical,drop_first=True)\n",
    "X = pd.concat([numerical, cat_numerical], axis = 1)\n",
    "X.head()\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,  test_size=0.20, random_state=0)\n",
    "\n",
    "#applying scaling on training and test data\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc = StandardScaler()\n",
    "X_train = sc.fit_transform(X_train)\n",
    "X_test = sc.transform (X_test)\n",
    "\n",
    "#importing PCA class\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "#creating object of the PCA class\n",
    "pca = PCA()\n",
    "\n",
    "#training PCA model on training data\n",
    "X_train = pca.fit_transform(X_train)\n",
    "\n",
    "#making predictions on test data\n",
    "X_test = pca.transform(X_test)\n",
    "\n",
    "#printing variance ratios\n",
    "variance_ratios = pca.explained_variance_ratio_\n",
    "print(variance_ratios)\n",
    "\n",
    "#use one principle component\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X_train = pca.fit_transform(X_train)\n",
    "X_test = pca.transform(X_test)\n",
    "\n",
    "#making predictions using logistic regression\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "#training the logistic regression model\n",
    "lg = LogisticRegression()\n",
    "lg.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = lg.predict(X_test)\n",
    "\n",
    "#evaluating results\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "print(accuracy_score(y_test, y_pred))\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "#print actual datapoints\n",
    "\n",
    "plt.scatter(X_test[:,0], X_test[:,1], c= y_test, cmap='rainbow' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
